\documentclass{bv1}

\begin{document}

% \maketitle{Nummer}{Abgabedatum}{Tutor-Name}{Gruppennummer}
%           {Teilnehmer 1}{Teilnehmer 2}{Teilnehmer 3}
\maketitle{2}{29.11.2011}{Martin Stommel}{13} 
						{Janka Wöbbekind}{Robert Thiel}{Jonas Hansen}
						
\section{Kontrastanpassung}
Unsere Automatische Kontrastanpassung ermittelt zunächst $a_{low}$ und $a_{high}$, über den $GenericDialog$ wird des Weiteren der Prozentwert für $s_{low}$ und $s_{high}$ eingeholt. Diese werden in konkrete Pixelzahlen umgerechnet und alle darunter (bzw darüber) liegenden Grauwerte aufaddiert, bis $\widehat{a}_{low}$ und $\widehat{a}_{high}$ erreicht wird.\\
Zuletzt wird jeder Pixel mit der neuen Grauwertverteilung gezeichnet.\\
\\
Sollte ein Prozentwert nicht genau getroffen werden, rundet unser Programm auf den nächst höheren Wert auf. Dies geschieht durch die Bedingungen $if (suml>=threshlow)$ und $if (sumh>=threshhigh)$.
\begin{verbatim}
public static void kont(final ImageProcessor ip) {
		final int h = ip.getHeight();
		final int w = ip.getWidth();

		int alow = 255, ahigh = 0;
		for (int y = 0; y < h; ++y) {
			for (int x = 0; x < w; ++x) {							
				final int a = ip.getPixel(x, y);
				if (a<alow) alow = a;
				if (a>ahigh) ahigh = a;  
			}
		}
		double slow=1,shigh=1;
		GenericDialog gd = new GenericDialog("Werteingabe");
		gd.addMessage("Eingabe in Prozent");
		gd.addNumericField("s_low: ", slow, 1, 4, "%");
		gd.addNumericField("s_high: ", shigh, 1, 4, "%");
		gd.showDialog();
		if (gd.wasCanceled()) return;
		slow = gd.getNextNumber();
		shigh = gd.getNextNumber();

		int adlow=alow, adhigh=ahigh;
		double threshlow=h*w*slow*0.01;
		double threshhigh=h*w*shigh*0.01;

		int[] H = ip.getHistogram();

		int suml=0;
		for (int i=0; i<256; i++) {
			suml+=H[i];
			if (suml>=threshlow) {
				adlow=i;
				break;
			}
		}
		int sumh=0;
		for (int i=255; i>=0; i--) {
			sumh+=H[i];
  		if (sumh>=threshhigh) {
				adhigh=i;
				break;
			}
		}

		for (int y = 0; y < h; ++y) {
			for (int x = 0; x < w; ++x) {							
				final int p = ip.getPixel(x, y);
				final int a = ((p-adlow)*255)/(adhigh-adlow);
				ip.putPixel(x, y, a);
			}
		}
	}
\end{verbatim}

\section{Histogrammausgleich mit kumulativem Histogramm}
Bei der Programmierung des Histogrammausgleichs haben wir uns am Löungsvorschlag aus dem Buch "`Digitale Bildverarbeitung"' von Burger und Burge orientiert.\\
\\
Für den Histogrammausgleich wird nach der Parameterbestimmung das kumulative Histogramm erstellt. Dazu wird die ImageJ-Funktion $getHistogram$ für das normale Histogramm verwendet und anschließend der jeweils vorherige Eintrag in einer for-Schleife aufaddiert.\\
Zur Berechnung der neuen Pixelwerte wird der alte Wert ausgelesen. Die Häufigkeit des Werts wird mit dem höchsten Grauwert multipliziert und dann durch die gesamte Pixelanzahl dividiert.\\
\\
Wenn man die Ausgangsbilder mit den Ergebnisbildern vergleicht, sind bei lena2-1 und lena 2-2 deutliche Unterschiede zu erkennen. Die Motive sind wesentlich besser zu erkennen, durch ein höhere Helligkeit und einen stärkeren Kontrast. Allerdings sind die Grauwertverläufe sehr grob, da das Ausgangsbild wenig Informationen zur Verfügung stellt, welche über den gesamten Wertebereich gestreckt werden. Die weißen und schwarzen Pixel von lena2-2 sind nach der Anwendung des Histogrammausgleichs noch immer zu erkennen, allerdings weniger deutlich, da der Kontrast zum restlichen Bild geringer ist. Beim Vergleich der Histogramme der Ergebnisbilder ist zu sehen, dass diese sehr ähnlich sind, nur im Bereich der weißen und schwarzen Pixel sind Unterschiede auszumachen.\\
Nachdem das Plugin auf rechtecke angewendet wurde, ist ein Schriftzug zu erkennen, der im Ausgangsbild mit dem bloßen Auge nicht zu sehen war. Die weißen Pixel sind gleich geblieben und die restlichen Grauwerte haben sich in einen helleren Bereich verschoben, dadurch ist der Kontrast der Pixel des Rechtecks zu den Pixeln des Schriftzugs größer geworden.\\
\\
Wenn der Histogrammausgleich mehrfach angewendet wird, gibt es keinen Unterschied zu einem einfach angewendeten Histogrammausgleich. Der Grund dafür ist, dass der Histogrammausgleich dafür sorgt, dass das kumulative Histogramm eine Keilform annimmt. Bei erneutem Anwenden ist das Ziel bereits erreicht, also wird nichts weiter verändert.\\
\\
Beim Histogrammausgleich sind keine weiteren Parameter nötig, da die Grauwerte über den gesamten Wertebereich gestreckt werden, es werden also keine Bereiche zusammengefasst oder gelöscht, für die zusätzliche Parameter angegeben werden müssten.

\begin{verbatim}
public static void histaus(final ImageProcessor ip) {
	final int h = ip.getHeight();
	final int w = ip.getWidth();
	int M = w*h; 
	int K = 256; 

	int[] H = ip.getHistogram();
	for (int j = 1; j < H.length; j++) {
		H[j] = H[j-1] + H[j];
	}

	for (int y = 0; y < h; y++) {
		for (int x = 0; x < w; x++) {
			int a = ip.getPixel(x, y);
			int b = H[a] * (K - 1) / M;
			ip.putPixel(x, y, b);
		}
	}
}
\end{verbatim}


\section{Binarisierung mit automatischem Schwellwert}
Der Implementierte Binarisierungsfilter legt den Schwellwert der Operation automatisch fest, indem er den ersten und letzen Grauwert ermittelt und den Mittelpunkt zwischen diesen beiden als Schwellwert wählt. Wir haben diese Methode gewählt, da sie einfach und unserer Meinung nach effektiv genug ist.\\
Bei Anwendung unseres Filters auf Bild 1 erzielt der Filter kein optimales Ergebnis, die Umrisse des weißen Gebildes aus dem Originalbild lassen sich jedoch noch im groben erkennen. Unsere Methode ist für dieses Bild eher ungeeignet, da Bild 1 eine Häufung von Grauwerten um den Mittelwert herum aufweist. Durch unsere Schwellwertwahl werden fast alle mittleren Graustufen auf weiß gesetzt.\\
Bei Bild 2 lässt sich der Schlüssel leicht erkennen. Unser Schwellwert liegt hier besser, da sich ein Häufungspunkt der Grauwerte größtenteils links und der andere Häufungspunkt rechts von ihm befindet.\\
Für Bild 3 verhält sich der Filter wie für Bild 2, der Schwellwert liegt zwischen den Häufungspunkten der Grauwerte.\\
\\
Generell kann man also sagen, das eine Binarisierung zum Erfolg führt, wenn das Ursprungsbild bereits eine Tendenz zu einem hellen und einem dunklen Häufungspunkt aufweist. Diese sollten natürlich idealerweise nicht nahe dem Mittelwert liegen.\\
Sollte dennoch ein Bild wie $binarisierung1.png$ vorliegen (also mit Häufungspunkten nahe dem Mittelwert), kann man den Erfolg der Binarisierung generell gewährleisten, wenn man zuvor eine geeignete Kontrastanpassung durchführt. Hierdurch werden Häufungspunkte in den hellen und dunklen Bereich gerückt.\\

\begin{verbatim}
	public static void bin(final ImageProcessor ip) {
		final int h = ip.getHeight();
		final int w = ip.getWidth();
		int i = 0;
		int j = 255;

		for (int y = 0; y < h; ++y) { 
			for (int x = 0; x < w; ++x) {							
				final int p = ip.getPixel(x, y);
				if (p > i) i = p;
				if (j > p) j = p;
			}
		}

		i = ((i-j)/2) + j;	

		for (int y = 0; y < h; ++y) {
			for (int x = 0; x < w; ++x) {							
				final int k = ip.getPixel(x, y);
				if (k > i) ip.putPixel(x, y, 255);
				else ip.putPixel(x, y, 0);
	    	}
		}
	}
\end{verbatim}

\end{document}